﻿/// @author: Bruno Figueira 11234
/// @author: Luis Pereira 12784
/// @last updated: 26-01-2015

using srccsharp.model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace srccsharp.controller
{
    /// <summary>
    /// Classe que define todas as operações necessárias
    /// para enviar dados ao Model e View
    /// </summary>
    class Controller
    {
        public static int STAT_IPC = 0;
        public static int STAT_TAXA = 1;
        public static int STAT_REMUN_MIN = 2;
        public static int STAT_REMUN_MAX = 3;
        public static int STAT_EV_MIN = 4;
        public static int STAT_EV_MAX = 5;
        public static int STAT_PIB = 6;
        public static int STAT_REND_NACIONAL = 7;
        public static int STAT_REND_DISPONIVEL = 8;
        public static int STAT_REMUN_ANUAIS = 9;
        private DBManager dbmanager;

        /// <summary>
        /// Construtor da classe Controller
        /// </summary>
        public Controller()
        {
            this.dbmanager = new DBManager();
        }

        /// <summary>
        /// Chama a função necessária para inserir os
        /// valores na base de dados
        /// </summary>
        /// <param name="filename">Nome do ficheiro Excel</param>
        public void LoadDataFromXLS(String filename) 
        {
            this.dbmanager.ClearTable();
            ReadExcel readExcel = new ReadExcel(filename);
            readExcel.LoadToDB(this.dbmanager);
        }

        /// <summary>
        /// Permite efetuar consultas à base de dados
        /// através de uma lista com os objetos IPC
        /// </summary>
        public void SelectInDB()
        {
            List<IPC> list = this.dbmanager.GetAllData();

            foreach (IPC ipc in list) 
            {
                Console.WriteLine(ipc);
            }
            Console.ReadLine();
        }

        /// <summary>
        /// Função que recebe o gráfico a ser executado (stat) e o intervalo
        /// de anos definido
        /// </summary>
        /// <param name="stat">numero que define qual a estatística a ser apresentada</param>
        /// <param name="startYear">Ano inicial</param>
        /// <param name="endYear">Ano final</param>
        /// <returns>Túpulo com a lista de anos e do stat pretendido</returns>
        public Tuple<List<int>, List<float>> use_plot_graphics(int stat, int startYear, int endYear)
        {
            if (stat == Controller.STAT_IPC)
            {
                return plot_ipc(startYear, endYear);
            }
            else if (stat == Controller.STAT_TAXA)
            {
                return plot_taxa_inflacao(startYear, endYear);
            }
            else if (stat == Controller.STAT_REMUN_MIN)
            {
                return plot_remun_min(startYear, endYear);
            }
            else if (stat == Controller.STAT_REMUN_MAX)
            {
                return plot_remun_max(startYear, endYear);
            }
            else if (stat == Controller.STAT_EV_MIN)
            {
                return plot_evolucao_minima(startYear, endYear);
            }
            else if (stat == Controller.STAT_EV_MAX)
            {
                return plot_evolucao_maxima(startYear, endYear);
            }
            else if (stat == Controller.STAT_PIB)
            {
                return plot_pib(startYear, endYear);
            }
            else if (stat == Controller.STAT_REND_NACIONAL)
            {
                return plot_rend_nac_bruto(startYear, endYear);
            }
            else if (stat == Controller.STAT_REND_DISPONIVEL)
            {
                return plot_rend_disp_bruto(startYear, endYear);
            }
            else
            {
                return plot_remun_anuais(startYear, endYear);
            }
        }

        /// <summary>
        /// Funcao que recebe o startYear e endYear de forma a mostrar 
        /// a estatistica do IPC-Global
        /// </summary>
        /// <param name="startYear">Ano inicial</param>
        /// <param name="endYear">Ano final</param>
        /// <returns>Túpulo com a lista de anos e do ipc_global</returns>
        public Tuple<List<int>, List<float>> plot_ipc(int startYear, int endYear)
        {
            List<int> anos = new List<int>();
            List<float> ipc_global = new List<float>();

            foreach (IPC ipc in this.dbmanager.GetDataFilteredByYears(startYear, endYear))
            {
                anos.Add(ipc.ano);
                ipc_global.Add(ipc.ipc_global);
            }

            return new Tuple<List<int>, List<float>>(anos, ipc_global);
        }

        /// <summary>
        /// Funcao que recebe o startYear e endYear de forma a mostrar 
        /// a estatistica da Taxa de Inflacao
        /// </summary>
        /// <param name="startYear">Ano inicial</param>
        /// <param name="endYear">Ano final</param>
        /// <returns>Túpulo com a lista de anos e da taxa de inflação</returns>
        public Tuple<List<int>, List<float>> plot_taxa_inflacao(int startYear, int endYear)
        {
            List<int> anos = new List<int>();
            List<float> taxa_inflacao = new List<float>();

            foreach (IPC ipc in this.dbmanager.GetDataFilteredByYears(startYear, endYear))
            {
                anos.Add(ipc.ano);
                taxa_inflacao.Add(ipc.taxa_de_inflacao);
            }

            return new Tuple<List<int>, List<float>>(anos, taxa_inflacao);
        }

        /// <summary>
        /// Funcao que recebe o startYear e endYear de forma a mostrar 
        /// a estatistica das Remunrações Minimas
        /// </summary>
        /// <param name="startYear">Ano inicial</param>
        /// <param name="endYear">Ano final</param>
        /// <returns>Túpulo com a lista de anos e da remuneração minima</returns>
        public Tuple<List<int>, List<float>> plot_remun_min(int startYear, int endYear)
        {
            List<int> anos = new List<int>();
            List<float> remun_min = new List<float>();

            foreach (IPC ipc in this.dbmanager.GetDataFilteredByYears(startYear, endYear))
            {
                anos.Add(ipc.ano);
                remun_min.Add(ipc.remun_min_mensal);
            }

            return new Tuple<List<int>, List<float>>(anos, remun_min);
        }

        /// <summary>
        /// Funcao que recebe o startYear e endYear de forma a mostrar 
        /// a estatistica das Remunerações Máximas
        /// </summary>
        /// <param name="startYear">Ano inicial</param>
        /// <param name="endYear">Ano final</param>
        /// <returns>Túpulo com a lista de anos e da remuneração máxima</returns>
        public Tuple<List<int>, List<float>> plot_remun_max(int startYear, int endYear)
        {
            List<int> anos = new List<int>();
            List<float> remun_max = new List<float>();

            foreach (IPC ipc in this.dbmanager.GetDataFilteredByYears(startYear, endYear))
            {
                anos.Add(ipc.ano);
                remun_max.Add(ipc.remun_max_mensal);
            }

            return new Tuple<List<int>, List<float>>(anos, remun_max);
        }

        /// <summary>
        /// Funcao que recebe o startYear e endYear de forma a mostrar 
        /// a estatistica da Evolução das Remunerações Minimas
        /// </summary>
        /// <param name="startYear">Ano inicial</param>
        /// <param name="endYear">Ano final</param>
        /// <returns>Túpulo com a lista de anos e da evolução mínima</returns>
        public Tuple<List<int>, List<float>> plot_evolucao_minima(int startYear, int endYear)
        {
            List<int> anos = new List<int>();
            List<float> ev_min = new List<float>();

            foreach (IPC ipc in this.dbmanager.GetDataFilteredByYears(startYear, endYear))
            {
                anos.Add(ipc.ano);
                if (ipc.ipc_global != 0.0)
                {
                    ev_min.Add(ipc.remun_min_mensal / ipc.ipc_global);
                }
                else
                {
                    ev_min.Add(0.0F);
                }
            }

            return new Tuple<List<int>, List<float>>(anos, ev_min);
        }

        /// <summary>
        /// Funcao que recebe o startYear e endYear de forma a mostrar 
        /// a estatistica da Evolução das Remunerações Máximas
        /// </summary>
        /// <param name="startYear">Ano inicial</param>
        /// <param name="endYear">Ano final</param>
        /// <returns>Túpulo com a lista de anos e da evolução máxima</returns>
        public Tuple<List<int>, List<float>> plot_evolucao_maxima(int startYear, int endYear)
        {
            List<int> anos = new List<int>();
            List<float> ev_max = new List<float>();

            foreach (IPC ipc in this.dbmanager.GetDataFilteredByYears(startYear, endYear))
            {
                anos.Add(ipc.ano);
                if (ipc.ipc_global != 0.0)
                {
                    ev_max.Add(ipc.remun_min_mensal / ipc.ipc_global);
                }
                else
                {
                    ev_max.Add(0.0F);
                }
            }

            return new Tuple<List<int>, List<float>>(anos, ev_max);
        }

        /// <summary>
        /// Funcao que recebe o startYear e endYear de forma a mostrar 
        /// a estatistica do PIB Anual
        /// </summary>
        /// <param name="startYear">Ano inicial</param>
        /// <param name="endYear">Ano final</param>
        /// <returns>Túpulo com a lista de anos e do pib</returns>
        public Tuple<List<int>, List<float>> plot_pib(int startYear, int endYear)
        {
            List<int> anos = new List<int>();
            List<float> pib = new List<float>();

            foreach (IPC ipc in this.dbmanager.GetDataFilteredByYears(startYear, endYear))
            {
                anos.Add(ipc.ano);
                pib.Add(ipc.pib_anual);
            }

            return new Tuple<List<int>, List<float>>(anos, pib);
        }

        /// <summary>
        /// Funcao que recebe o startYear e endYear de forma a mostrar 
        /// a estatistica do Rendimento Nacional Bruto
        /// </summary>
        /// <param name="startYear">Ano inicial</param>
        /// <param name="endYear">Ano final</param>
        /// <returns>Túpulo com a lista de anos e do rendimento nacional bruto</returns>
        public Tuple<List<int>, List<float>> plot_rend_nac_bruto(int startYear, int endYear)
        {
            List<int> anos = new List<int>();
            List<float> rend_nac_bruto = new List<float>();

            foreach (IPC ipc in this.dbmanager.GetDataFilteredByYears(startYear, endYear))
            {
                anos.Add(ipc.ano);
                rend_nac_bruto.Add(ipc.rendimento_nacional_bruto_anual);
            }

            return new Tuple<List<int>, List<float>>(anos, rend_nac_bruto);
        }

        /// <summary>
        /// Funcao que recebe o startYear e endYear de forma a mostrar 
        /// a estatistica do Rendimento Disponível Bruto
        /// </summary>
        /// <param name="startYear">Ano inicial</param>
        /// <param name="endYear">Ano final</param>
        /// <returns>Túpulo com a lista de anos e do rendimento disponivel bruto</returns>
        public Tuple<List<int>, List<float>> plot_rend_disp_bruto(int startYear, int endYear)
        {
            List<int> anos = new List<int>();
            List<float> rend_disp_bruto = new List<float>();

            foreach (IPC ipc in this.dbmanager.GetDataFilteredByYears(startYear, endYear))
            {
                anos.Add(ipc.ano);
                rend_disp_bruto.Add(ipc.rendimento_disponivel_bruto_anual);
            }

            return new Tuple<List<int>, List<float>>(anos, rend_disp_bruto);
        }

        /// <summary>
        /// Funcao que recebe o startYear e endYear de forma a mostrar 
        /// a estatistica das Remunerações Anuais
        /// </summary>
        /// <param name="startYear">Ano inicial</param>
        /// <param name="endYear">Ano final</param>
        /// <returns>Túpulo com a lista de anos e das remunerações anuais</returns>
        public Tuple<List<int>, List<float>> plot_remun_anuais(int startYear, int endYear)
        {
            List<int> anos = new List<int>();
            List<float> remun_anuais = new List<float>();

            foreach (IPC ipc in this.dbmanager.GetDataFilteredByYears(startYear, endYear))
            {
                anos.Add(ipc.ano);
                remun_anuais.Add(ipc.remuneracoes_anual);
            }

            return new Tuple<List<int>, List<float>>(anos, remun_anuais);
        }
        
    }
}
